/**
 * 麦克风SDK
 * 提供麦克风访问、音频分析和回放功能，支持自定义界面
 * 
 * 2025版本 - 模块化重构
 */

// 导入核心模块
import audioProcessor from './core/audioProcessor.js';
import deviceManager from './core/devices.js';
import eventEmitter, { EventTypes } from './core/events.js';
import * as utils from './core/utils.js';

// SDK状态
let isListening = false;
let isPlayingBack = false;
let audioBuffer = null;
let audioSource = null;
let customUILoaded = false;

/**
 * 麦克风SDK类
 * 提供麦克风控制的主要功能
 */
export class MicrophoneSDK {
  constructor() {
    // 初始化时连接事件处理
    this._setupEventHandlers();
    
    // 检查浏览器支持
    this.browserSupport = utils.checkBrowserSupport();
    
    // 调试模式
    this.debugMode = utils.isDebugMode();
    
    // 创建解锁音频上下文的事件处理函数
    this._unlockAudioContextHandler = this.unlockAudioContext.bind(this);
    
    // 记录初始化日志
    utils.debugLog('麦克风SDK初始化', {
      browserSupport: this.browserSupport,
      debugMode: this.debugMode,
      isUE5: utils.isUE5Environment(),
      isMobile: utils.isMobileDevice()
    });
  }

  /**
   * 设置事件处理器
   * @private
   */
  _setupEventHandlers() {
    // 连接音频处理器的音频电平变化事件
    audioProcessor.onAudioLevelChange = (level) => {
      eventEmitter.emit(EventTypes.AUDIO_LEVEL, level);
    };
    
    // 连接设备管理器的权限变化事件
    deviceManager.onPermissionChange = (hasPermission) => {
      eventEmitter.emit(EventTypes.PERMISSION, hasPermission);
    };
    
    // 连接设备管理器的设备列表变化事件
    deviceManager.onDeviceListChange = (devices) => {
      eventEmitter.emit(EventTypes.MICROPHONE_LIST, devices);
    };
  }

  /**
   * 初始化SDK
   * @returns {Promise<boolean>} 初始化是否成功
   */
  async initialize() {
    try {
      // 初始化音频处理器
      const audioInitialized = await audioProcessor.initialize();
      if (!audioInitialized) {
        throw new Error('音频处理器初始化失败');
      }
      
      // 检查麦克风权限
      await deviceManager.checkPermission();
      
      // 枚举麦克风设备
      await deviceManager.enumerateMicrophones();
      
      // 添加用户交互事件监听器，用于解锁音频上下文
      document.addEventListener('click', this._unlockAudioContextHandler);
      document.addEventListener('touchstart', this._unlockAudioContextHandler);
      document.addEventListener('keydown', this._unlockAudioContextHandler);
      
      return true;
    } catch (error) {
      console.error('初始化SDK失败:', error);
      eventEmitter.emit(EventTypes.ERROR, {
        type: 'initialization',
        message: '初始化SDK失败',
        error
      });
      return false;
    }
  }

  /**
   * 解锁音频上下文
   * @returns {Promise<boolean>} 解锁是否成功
   */
  async unlockAudioContext() {
    return audioProcessor.unlockAudioContext();
  }

  /**
   * 开始监听麦克风
   * @returns {Promise<boolean>} 是否成功开始监听
   */
  async startListening() {
    try {
      // 如果已经在监听，直接返回
      if (isListening) {
        return true;
      }
      
      // 获取麦克风流
      const stream = await deviceManager.getMicrophoneStream();
      if (!stream) {
        throw new Error('无法获取麦克风流');
      }
      
      // 连接麦克风流到音频处理器
      audioProcessor.connectMicrophoneStream(stream);
      
      // 更新状态
      isListening = true;
      
      // 发布状态变化事件
      eventEmitter.emit(EventTypes.MICROPHONE_STATUS, this.getMicrophoneStatus());
      
      utils.debugLog('开始监听麦克风');
      return true;
    } catch (error) {
      console.error('开始监听麦克风失败:', error);
      eventEmitter.emit(EventTypes.ERROR, {
        type: 'startListening',
        message: '开始监听麦克风失败',
        error
      });
      return false;
    }
  }

  /**
   * 停止监听麦克风
   * @returns {Promise<boolean>} 是否成功停止监听
   */
  async stopListening() {
    try {
      // 如果没有在监听，直接返回
      if (!isListening) {
        return true;
      }
      
      // 断开麦克风流
      audioProcessor.disconnectMicrophoneStream();
      
      // 更新状态
      isListening = false;
      
      // 发布状态变化事件
      eventEmitter.emit(EventTypes.MICROPHONE_STATUS, this.getMicrophoneStatus());
      
      utils.debugLog('停止监听麦克风');
      return true;
    } catch (error) {
      console.error('停止监听麦克风失败:', error);
      eventEmitter.emit(EventTypes.ERROR, {
        type: 'stopListening',
        message: '停止监听麦克风失败',
        error
      });
      return false;
    }
  }

  /**
   * 获取麦克风状态
   * @returns {Object} 麦克风状态对象
   */
  getMicrophoneStatus() {
    return {
      isListening,
      hasPermission: deviceManager.hasPermission,
      audioLevel: audioProcessor.audioLevel,
      isPlayingBack,
      selectedMicrophone: deviceManager.getSelectedMicrophone()
    };
  }

  /**
   * 获取可用麦克风列表
   * @returns {Array} 麦克风设备列表
   */
  getAvailableMicrophones() {
    return deviceManager.availableMicrophones;
  }

  /**
   * 选择麦克风设备
   * @param {string} deviceId - 设备ID
   * @returns {Promise<boolean>} 是否成功选择设备
   */
  async selectMicrophone(deviceId) {
    try {
      // 选择设备
      const device = deviceManager.selectMicrophone(deviceId);
      if (!device) {
        throw new Error(`未找到ID为${deviceId}的麦克风设备`);
      }
      
      // 如果正在监听，需要重新启动以使用新设备
      if (isListening) {
        await this.stopListening();
        await this.startListening();
      }
      
      utils.debugLog('选择麦克风设备', device);
      return true;
    } catch (error) {
      console.error('选择麦克风设备失败:', error);
      eventEmitter.emit(EventTypes.ERROR, {
        type: 'selectMicrophone',
        message: '选择麦克风设备失败',
        error
      });
      return false;
    }
  }

  /**
   * 刷新麦克风设备列表
   * @returns {Promise<Array>} 更新后的麦克风设备列表
   */
  async refreshMicrophoneList() {
    return deviceManager.enumerateMicrophones();
  }

  /**
   * 设置增益值
   * @param {number} value - 增益值 (0-2)
   */
  setGain(value) {
    audioProcessor.setGain(value);
  }

  /**
   * 加载自定义UI
   * @param {string} uiPath - UI模块路径
   * @returns {Promise<boolean>} 是否成功加载UI
   */
  async loadCustomUI(uiPath) {
    try {
      // 这里可以实现自定义UI加载逻辑
      // 为简化起见，我们只设置一个标志
      customUILoaded = true;
      
      utils.debugLog('加载自定义UI', uiPath);
      return true;
    } catch (error) {
      console.error('加载自定义UI失败:', error);
      eventEmitter.emit(EventTypes.ERROR, {
        type: 'loadCustomUI',
        message: '加载自定义UI失败',
        error
      });
      return false;
    }
  }

  /**
   * 清理资源
   */
  dispose() {
    // 停止监听
    this.stopListening();
    
    // 清理音频处理器
    audioProcessor.dispose();
    
    // 移除事件监听器
    document.removeEventListener('click', this._unlockAudioContextHandler);
    document.removeEventListener('touchstart', this._unlockAudioContextHandler);
    document.removeEventListener('keydown', this._unlockAudioContextHandler);
    
    // 清理事件发射器
    eventEmitter.removeAllListeners();
    
    utils.debugLog('SDK资源已清理');
  }

  /**
   * 获取原始麦克风媒体流
   * 可用于连接到语音识别等外部服务
   * @returns {MediaStream|null} 麦克风媒体流
   */
  getMicrophoneStream() {
    return audioProcessor.getMicrophoneStream();
  }

  /**
   * 注册音频数据回调函数
   * 用于实时处理音频数据，例如连接到语音识别服务
   * @param {Function} callback - 回调函数，接收音频数据对象 {audioData, sampleRate, timestamp}
   * @returns {Function} 取消注册的函数
   * @example
   * // 注册回调
   * const unsubscribe = MicrophoneSDK.registerAudioDataCallback(data => {
   *   // 处理音频数据
   *   console.log('接收到音频数据:', data.audioData.length, '采样率:', data.sampleRate);
   *   
   *   // 可以将数据发送到语音识别服务
   *   speechRecognitionService.processAudio(data.audioData);
   * });
   * 
   * // 取消注册
   * unsubscribe();
   */
  registerAudioDataCallback(callback) {
    return audioProcessor.registerAudioDataCallback(callback);
  }

  /**
   * 设置音频处理配置
   * @param {Object} config - 配置对象
   * @param {boolean} [config.enabled] - 是否启用音频处理
   * @param {number} [config.sampleRate] - 采样率
   * @param {number} [config.bufferSize] - 缓冲区大小
   * @param {number} [config.inputChannels] - 输入通道数
   * @param {number} [config.outputChannels] - 输出通道数
   */
  setAudioProcessingConfig(config) {
    audioProcessor.setProcessingConfig(config);
  }

  /**
   * 获取当前音频处理配置
   * @returns {Object} 当前配置
   */
  getAudioProcessingConfig() {
    return audioProcessor.getProcessingConfig();
  }
}

// 创建SDK实例
const sdk = new MicrophoneSDK();

// 导出SDK接口
const MicrophoneSDKInterface = {
  // 核心功能
  initialize: () => sdk.initialize(),
  startListening: () => sdk.startListening(),
  stopListening: () => sdk.stopListening(),
  getMicrophoneStatus: () => sdk.getMicrophoneStatus(),
  getAvailableMicrophones: () => sdk.getAvailableMicrophones(),
  selectMicrophone: (deviceId) => sdk.selectMicrophone(deviceId),
  refreshMicrophoneList: () => sdk.refreshMicrophoneList(),
  setGain: (value) => sdk.setGain(value),
  unlockAudioContext: () => sdk.unlockAudioContext(),
  loadCustomUI: (uiPath) => sdk.loadCustomUI(uiPath),
  dispose: () => sdk.dispose(),
  
  // 事件订阅
  onMicrophoneStatusChange: (callback) => eventEmitter.on(EventTypes.MICROPHONE_STATUS, callback),
  onAudioLevelChange: (callback) => eventEmitter.on(EventTypes.AUDIO_LEVEL, callback),
  onPermissionChange: (callback) => eventEmitter.on(EventTypes.PERMISSION, callback),
  onPlaybackStatusChange: (callback) => eventEmitter.on(EventTypes.PLAYBACK_STATUS, callback),
  onMicrophoneListChange: (callback) => eventEmitter.on(EventTypes.MICROPHONE_LIST, callback),
  onError: (callback) => eventEmitter.on(EventTypes.ERROR, callback),
  
  // 工具函数
  utils: {
    isDebugMode: utils.isDebugMode,
    isMobileDevice: utils.isMobileDevice,
    isUE5Environment: utils.isUE5Environment,
    formatTime: utils.formatTime
  }
};

// 为UE5提供全局访问点
window.MicrophoneControl = MicrophoneSDKInterface;

// 导出SDK接口
export default MicrophoneSDKInterface; 